/*
迭代器模式（Iterator Pattern）是一种行为型设计模式，它提供了一种顺序访问聚合对象中各个元素的方法，而不需要暴露聚合对象的内部表示。
通过使用迭代器模式，我们可以在不暴露聚合对象内部结构的情况下，让客户端遍历聚合对象中的元素。

在迭代器模式中，有三个核心角色：

1. 迭代器（Iterator）：定义了访问和遍历聚合对象元素的接口。
2. 具体迭代器（Concrete Iterator）：实现迭代器接口，负责具体的遍历聚合对象的操作。
3. 聚合对象（Aggregate）：定义了创建迭代器对象的接口。
4. 具体聚合对象（Concrete Aggregate）：实现聚合对象接口，创建具体迭代器对象。

迭代器模式的核心思想是将遍历操作从聚合对象中分离出来，使得聚合对象和遍历操作可以独立变化。
客户端通过迭代器来遍历聚合对象，而不需要知道聚合对象的内部结构。

下面是一个使用迭代器模式的C语言例程：
*/

#include <stdio.h>
#include <stdlib.h>

// 迭代器接口
typedef struct
{
    void *data;
    void *(*next)(void *iterator);
    int (*hasNext)(void *iterator);
} Iterator;

// 具体迭代器
typedef struct
{
    Iterator base;
    int index;
    int size;
    int *data;
} ConcreteIterator;

void *next(void *iterator)
{
    ConcreteIterator *concreteIterator = (ConcreteIterator *)iterator;
    int *data = &(concreteIterator->data[concreteIterator->index]);
    concreteIterator->index++;
    return (void *)data;
}

int hasNext(void *iterator)
{
    ConcreteIterator *concreteIterator = (ConcreteIterator *)iterator;
    return concreteIterator->index < concreteIterator->size;
}

Iterator *createIterator(int *data, int size)
{
    ConcreteIterator *iterator = (ConcreteIterator *)malloc(sizeof(ConcreteIterator));
    iterator->base.data = data;
    iterator->base.next = next;
    iterator->base.hasNext = hasNext;
    iterator->index = 0;
    iterator->size = size;
    iterator->data = data;
    return (Iterator *)iterator;
}

// 聚合对象接口
typedef struct
{
    Iterator *(*createIterator)(void *aggregate);
} Aggregate;

// 具体聚合对象
typedef struct
{
    Aggregate base;
    int size;
    int *data;
} ConcreteAggregate;

Iterator *createIterator(void *aggregate)
{
    ConcreteAggregate *concreteAggregate = (ConcreteAggregate *)aggregate;
    return createIterator(concreteAggregate->data, concreteAggregate->size);
}

Aggregate *createAggregate(int *data, int size)
{
    ConcreteAggregate *aggregate = (ConcreteAggregate *)malloc(sizeof(ConcreteAggregate));
    aggregate->base.createIterator = createIterator;
    aggregate->size = size;
    aggregate->data = data;
    return (Aggregate *)aggregate;
}

int main()
{
    int data[] = {1, 2, 3, 4, 5};
    int size = sizeof(data) / sizeof(int);

    Aggregate *aggregate = createAggregate(data, size);
    Iterator *iterator = aggregate->createIterator(aggregate);

    while (iterator->hasNext(iterator))
    {
        int *value = (int *)iterator->next(iterator);
        printf("%d ", *value);
    }
    printf("\n");

    return 0;
}

/*
在上面的例程中，首先定义了迭代器接口Iterator，其中包含了next和hasNext方法。
然后，定义了具体迭代器ConcreteIterator，它实现了迭代器接口，并负责具体的遍历操作。
在createIterator函数中，创建了具体迭代器对象，并设置其遍历操作。
接下来，定义了聚合对象接口Aggregate，其中包含了createIterator方法。
然后，定义了具体聚合对象ConcreteAggregate，它实现了聚合对象接口，并创建了具体迭代器对象。
在createAggregate函数中，创建了具体聚合对象，并设置其创建迭代器对象的方法。
最后，在main函数中，创建了具体聚合对象和具体迭代器对象，并使用迭代器遍历聚合对象中的元素。

通过使用迭代器模式，我们可以将遍历操作从聚合对象中分离出来，使得聚合对象和遍历操作可以独立变化。
这样，我们可以在不改变聚合对象的情况下，定义不同的遍历方式。
同时，客户端只需要通过迭代器来遍历聚合对象，而不需要知道聚合对象的内部结构。
这提高了代码的灵活性和可维护性。
*/